import java.util.Random;

/**
 * @author ZhaoWenLong
 * @date 2021/2/19 上午9:59
 * <p>Description</p>
 * <h2>功能描述</h2>
 * 生成存在一个未知数的等式
 * <h3>主要功能：</h3>
 * <ol>
 *     <li>TODO</li>
 * </ol>
 * <h3>关联类</h3>
 * <p>参考链接：</p>
 * <h2>更新日志</h2>
 * [author]        [time]                      [version]          [desc]
 * ZhaoWenLong     2021/2/19 上午9:59             V1.0
 */

public class NumberTest {

    /** 每道题的数字个数 */
    private int numberNum = 3;
    /** 运算类型 支持加法、减法、加减法混合 */
    private CalculateType calculationMethod = CalculateType.MINGLE;
    /** 数值范围 */
    private int resultRange = 20;

    /** 生成数量 */
    private static final int GENERATE_NUM = 50;

    /**
     * 随机数工具
     */
    private static Random random = new Random();

    public static void main(String[] args) {
        NumberTest numberTest = new NumberTest();
        //运行50次
        for (int i = 0; i < GENERATE_NUM; i++) {
            int[] nums = numberTest.createNums();
            String str = numberTest.createStr(nums);
            System.out.println(str);
        }
    }

    /**
     * 获取数据数组
     * @return 数据数组
     */
    private int[] createNums() {

        //最后一位数为结果
        int[] nums = new int[numberNum + 1];
        //结果
        int resultNum = 0;

        //生成numberNum位数字
        for (int i = 0; i < numberNum; i++) {
            // true 加法
            boolean status = true;

            //判断加减法
            if (calculationMethod == CalculateType.MINGLE) {
                status = random.nextInt(2) == 0;
            } else if (calculationMethod == CalculateType.AND) {
                status = true;
            } else if (calculationMethod == CalculateType.SUB) {
                status = false;
            }
            int num = random.nextInt(resultRange - 1) + 1;

            //如果是减号，就将数赋值成负数
            if (!status) {
                num = -num;
            }
            nums[i] = num;
            resultNum += num;

            //如果计算的结果小于0或者大于20则重新计算
            if (resultNum < 0 || resultNum >= resultRange) {
                return createNums();
            }
        }
        //添加结果
        nums[numberNum] = resultNum;
        return nums;
    }

    /**
     * 将数据数组拼接成字符串
     * @param nums 数据数组
     * @return 公式字符串
     */
    private String createStr(int[] nums) {
        StringBuilder sb = new StringBuilder();

        //随机留空位置的下标
        int index = random.nextInt(nums.length);

        //因为第一个前面没有符号，所以单独拎出来
        if (0 == index) {
            sb.append(CalculateStr.BRACKETS.value);
        } else {
            sb.append(abs(nums[0]));
        }

        //循环拼接
        for (int i = 1; i < nums.length - 1; i++) {
            sb.append(judgeSymbol(nums[i]));
            if (i == index) {
                sb.append(CalculateStr.BRACKETS.value);
            } else {
                sb.append(abs(nums[i]));
            }
        }
        if (index == nums.length - 1) {
            //如果是最后一个
            sb.append(CalculateStr.EQUAL.value).append(CalculateStr.BRACKETS.value);
        } else {
            //如果不是最后一个
            sb.append(CalculateStr.EQUAL.value).append(nums[nums.length - 1]);
        }
        return sb.toString();
    }

    /**
     * 根据正负号判断加或减
     * @param num 数字
     * @return 加减
     */
    private String judgeSymbol(int num) {
        return num < 0 ? CalculateStr.SUB.value : CalculateStr.AND.value;
    }

    /**
     * 获取数字的绝对值
     * @param num 数字
     * @return 绝对值
     */
    private int abs(int num) {
        return num < 0 ? -num : num;
    }

    /**
     * 计算类型
     */
    public enum CalculateType {
        /** 加法 */
        AND,
        /** 减法 */
        SUB,
        /** 加减法混合 */
        MINGLE
    }

    /**
     * 计算符号（字符串）
     */
    private enum CalculateStr {
        /** 加法 */
        AND(" + "),
        /** 减法 */
        SUB(" - "),
        /** 等于 */
        EQUAL(" = "),
        /** 括号 */
        BRACKETS("（ ）");

        /**
         * value 值
         */
        private final String value;

        CalculateStr(String value) {
            this.value = value;
        }
    }

}
